Software application software architecture and method for the construction of software applications especially for measuring systems

ABSTRACT

Objects (with data, attributes, behavior, functions) for software applications, especially MES-applications, are linked to meta information and structured as hierarchical trees (whereby different forms of representation can be selected) and are branched or cross-linked together (laterally and/or horizontally). During the running time, the objects are added to form software applications whereby the common functions of the software applications are derived from the structure of the hierarchical trees. Software applications for MES-systems are constructed for automation systems, for industrial controls (also movement controls) and for office applications (office area).

CROSS REFERENCE TO RELATED APPLICATIONS

This application is the U.S. National Stage of International ApplicationNo. PCT/DE03/00412 , filed Feb. 12, 2003 and claims the benefit thereof.The International Application claims the benefits of German applicationNo. 10206903.4 filed Feb. 19, 2002, both of the applications areincorporated by reference herein in their entirety.

FIELD OF INVENTION

The invention relates to software applications, in particular MESapplications, comprising objects which contain and/or reference dataand/or attributes and/or behaviors, whereby the objects run on and/orare stored on at least one computer unit.

Furthermore, the invention relates to a software architecture, inparticular for MES applications, and to a method for building softwareapplications, in particular for MES systems.

The invention further relates to a software development environment, acomputer program, a data medium and a data processing device.

BACKGROUND OF INVENTION

The use of what are referred to as Manufacturing Execution Systems.(MES) for automating production and manufacturing processes is knownfrom “Software für die Automatisierung—Transparenz über die Abläufeschaffen” (“Software for automation—Creating transparency acrossprocesses), an article by Dirk Kozian in Elektronik für dieAutomatisierung 11 , Nov. 17, 1999 . These systems integrate theautomation level (Controls) with the ERP (Enterprise Resource Planning)systems of the enterprise management level. Manufacturing executionsystems are systems which, for example, provide information for theoptimization of production sequences or handle the coordination oroptimization of the production processes. On the one hand themanufacturing execution systems must supplement the general planningdata of the ERP systems by including system-specific and currentdetailed planning data and forward this accordingly to the subordinateautomation level. On the other hand they have the task of acceptingproduction-related information from the automation level, editing thisinformation and passing it on to the enterprise management level. One ofthe tasks fulfilled by MES systems is thus to implement verticalintegration between the enterprise resource planning level and theautomation level. Typical individual tasks of MES systems are enterpriseasset management, maintenance management, information management,scheduling, dispatching and trace and tracking. Each of these tasks isexecuted by MES components or, as the case may be, MES applications.

In the classical programming languages (e.g. Pascal or Fortran) thatwere used for producing software in the eighties, data and functionswere kept separate. It was not until the object-oriented programmingparadigm became established that data and functions were combined toform objects. In the nineties, isolated attempts were made to assignmeta data to the objects. Meta data is information about otherinformation, for example information about existing objects themselves.This meta data is in fact present in the overall system or in theoverall context, but it is neither physically stored in an object nordoes it contain knowledge about the application to be implemented orabout the business process to be implemented.

D. E. Perry and A. A. Wolf introduced the term “architectural style” in“Foundations for the Study of Software Architecture”, ACM SIGSOFT,Software Engineering Notes, Vol. 17, No. 4 . pp. 40-52 , October 1992 .In this publication reference is made inter alia to the consequences andinfluences of an architecture on an application based on thatarchitecture. However, it does not describe how advantages in terms ofthe production, configuration, reorganization or modifiability ofsoftware applications can be achieved through the targeted use of metainformation in a software architecture.

SUMMARY OF INVENTION

The object of the invention is to provide software applications, asoftware architecture and a method for producing software applicationswhich improves the modifiability and extensibility of systems.

The aforesaid object is achieved by the claims. The meta informationassigned to an object describes, for example, which data and functionsan object contains, but meta information can also include descriptionsfor implementation and operation or user documentation. In markuplanguages such as HTML or XML, meta information can be described bymeans of what are termed tags or by means of attributes and assigned tothe objects. Meta information can also be provided with a hierarchicalstructure. One advantage of the invention is that no explicit codegeneration is necessary in order to allow a software application toexecute.

The objects are black boxes with appropriate access mechanisms forreading the meta data. The runtime logic and the runtime executionsequence of the software application represented by the tree arespecified from the structure of the tree and from the way it isnetworked. The structure of the tree, which can be modified manually orautomatically at runtime, and the networking of the tree elementsdetermine which operands are supplied to functions and whether functionsare executed sequentially or in parallel. In industrial installationsthe structure of the tree and the networking of the tree elements areused to determine, for example, which input variables are to be suppliedto equipment and how the output values generated by the equipment are tobe further processed. Graphical editing of the tree and the networkingis performed by a user in a software development environment. The formof representation of the trees can vary and can be freely selected bythe user or to suit a specific application. The networking or pointercross-referencing of the tree elements can be achieved by thehierarchical arrangement in the tree. However, networking or pointercross-referencing of the tree elements can also be accomplished by meansof references edited by the user or by lateral networking links toelements of other subtrees. The inputs to create the tree and toestablish networking links can be made using input masks, drag&dropmechanisms or voice input.

The individual objects are assigned their implementation, i.e. theircode and meta information. Because the software application is assembledfrom prefabricated objects at runtime (e.g. automatically on the basisof the meta data relating to the application process), an explicitcompiler phase for generating the code of the software application to beproduced can be dispensed with. Compiler runs can take a very long time.The fact that explicit compiler runs are not required means that thetime taken to produce, test and commission the software application isreduced to a minimum.

A further significant advantage is that programs and data are handled ina uniform manner. Data are object trees without functions; programs areobject trees with functions. All the mechanisms present in a runtimesystem for assembling, networking, versioning, storing, transportingetc. data and programs only need to be implemented once and not onceeach for data and for programs. This also facilitates their handling forsoftware developers, commissioning engineers and administrators, sincethey only have to familiarize themselves once with these mechanisms.

A further advantage is that changes can be implemented very easily.Subtrees can be added, modified or removed at any time without theentire tree structure needing to be changed. This increases the agilityof an enterprise, since the enterprise can react more quickly to changedmarket requirements. This is important most especially when the softwareapplications are used for controlling automation systems, productionequipment or MES systems. The software applications according to theinvention can also be advantageously deployed in the office environment,however.

The networking, pointer cross-referencing or referencing between theobjects can take place using different degrees of granularity. Thus,networking can be achieved for example by reference to physicaladdresses (using pointers), thereby achieving a high level of efficiency(e.g. within the execution of a process). Other-networking mechanismsinclude, for example, electronic messages (e.g. e-mail), telephone orfax. The user can choose a suitable networking mechanism according tothe requirements of the underlying application.

Objects, in the context of the present invention, are those objects thatare used during the development of the software application, but alsoruntime objects. Runtime objects are objects which execute the logic ofthe system at the run time of a system (e.g. an application).

The software applications according to the invention are also suitablefor solutions for process control systems and production automationsystems.

A first advantageous embodiment of the present invention for a softwareapplication derives from the fact that at runtime the objects and/orreferencing mechanisms and/or networking mechanisms and/orimplementations of the objects are interchangeable. As a result of thefact that objects can be replaced at runtime by other objects, e.g. byobjects with extended functionality or the implementations of objects(e.g. the new implementations have been debugged or deliver betterperformance) or referencing and networking mechanisms, the turnaroundtime in the event of changes is substantially reduced. This increasesflexibility for the user and the operator of a system and the agility ofan enterprise. No ordinary compiler is used for the analysis of the metadata, but rather a so-called incremental compiler or an interpreterwhich is active on a local object basis only at the time of replacement.

Code is generated, if necessary incrementally, for the newly deployedobject and the incremental compiler or interpreter inserts the newlydeployed object (or, as the case may be, the referencing mechanismand/or networking mechanism and/or a new implementation of objects) intothe tree again at runtime, without the need to take into account other(unaffected) parts of the tree.

A further advantageous embodiment of the present invention for asoftware application derives from the fact that services can be added tothe objects at runtime. The services use the local object meta data inorder to make (MES or control) infrastructure functions genericallyavailable. Services of this kind can include, for example,serialization, replication, encryption or access control. In this waythe objects can be equipped with what is called “Quality of Services”. Auser of an object can rely on the execution of these services andabstract from their implementation.

A further advantageous embodiment of the present invention for asoftware application derives from the fact that implementations of thereferencing mechanisms or the networking mechanisms or the services canbe used for data and for programs. This means that the mechanisms andthe services do not have to be implemented separately for data and forprograms every time. Furthermore, meta information can be added to allobjects (regardless of whether they are data objects or program objects)in the same way and the meta information can be accessed in the same wayfor all objects.

A further advantageous embodiment of the present invention for asoftware application derives from the fact that the objects arenetworked statically and/or dynamically. Networking links (or, as thecase may be, pointer cross-references or references) can be implementedstatically in a manual building of the tree, but can also be generatedautomatically on the basis of current information or meta information(e.g. as necessary). This increases the flexibility for a user.Networking links can be set up using different mechanisms andimplementations: e.g. pointers to objects, e-mail to objects ornetworking via OPC protocols (OPC stands for OLE for Process Control).OPC protocols are frequently used in the industrial environment inparticular. Further techniques or implementations which can be used fornetworking or for linking are, for example, MSMQ (Microsoft MessageQueue), HTTP (Hypertext Transfer Protocol) or SOAP (Simple ObjectTransfer Protocol).

A further advantageous embodiment of the present invention for asoftware application derives from the fact that the objects physicallycontain the meta information. This supports the principle of localityduring the development of the software application, i.e. all information(including the meta information) which is important for an object isalso physically present in the object. Access to this information issimplified as a result. Because the objects physically include the metainformation, an object can also be used on its own for the organization,reorganization or reconfiguration of the software application, as afunction of which meta information (type and scope) is present in theobject. This is of advantage in particular for mobile objects, e.g. forsoftware agents which move from computer to computer on the Internet (orother networked systems such as, for example, an intranet) in order, forexample, to collect information on an installation, in each case on alocal computer basis, in a highly efficient manner e.g. for amaintenance system.

A further advantageous embodiment of the present invention for asoftware application derives from the fact that the meta informationcontains static and/or dynamic object models. Object models of this kindinclude, for example, classes and their relationships, state/eventmodels, activity models, deployment models or domain models (e.g. MESprocess model in specific branches of industry such as, for example,automobile manufacture, fertilizer production). This is of advantage inparticular for generic software development or for software generators.

A further advantageous embodiment of the present invention for asoftware application derives from the fact that the meta informationdescribes an application or a business process. If the meta informationcontains not only information about the object itself, but alsoinformation about the entire software application, about the deploymentenvironment or about the business process (or business logic) to beimplemented, then the configuration of the software application issimplified as a result, up to a point where a configuration can beperformed automatically. Reconfigurations (e.g. following system crashesor failure of parts of the system) can also be performed automaticallywithout human intervention. This increases the agility of an enterpriseand the availability of the production system.

A further advantageous embodiment of the present invention for asoftware application derives from the fact that each individual objectcontains the entire meta information relating to the application or thebusiness process. This means that in a software application or in asoftware system the entire description of the application or also of abusiness process is contained in each individual object (e.g. in thevery smallest tag, in each variable or in each operator, i.e. also inthe very fine granular objects). As a result of this information, eachindividual object can be used for a reorganization, but also aself-organization of the application, the system or the businessprocess. This is very advantageous, for example, in the case of systemerrors when large parts of the system fail. The system can regenerateitself completely from the smallest part that is still operational. Amaintenance engineer therefore does not need to be concerned with thelaborious task of obtaining and reading documentation.

A further advantageous embodiment of the present invention for asoftware application derives from the fact that the trees can berepresented in different views on a display device. The trees can berepresented differently, for example using a static Explorer-likenotation or in the form of workflow or flow diagrams (flowcharts,activity diagrams) or, for example, in the form of block diagrams (e.g.circuit diagrams) or layout plans (e.g. physical equipment layout,material flow plans). This greatly increases the flexibility for a user,for he can choose a notation or visualization appropriate to his levelof knowledge in order to inspect the meta information present in theruntime system. It is also possible to switch between the differentforms of representation.

A further advantageous embodiment of the present invention for asoftware application derives from the fact that if an error occurs thesoftware application reconfigures itself. If, in a software applicationor in a software system, the entire description of the application oralso of a business process is contained in each individual object (e.g.in the very smallest tag, in each variable or in each operator, i.e.also in the very fine granular objects), this information can be usedfor an automatic reorganization, i.e. a self-healing of the application,the system or the business process. User interventions are no longerrequired and downtimes are minimized. There is therefore no need for amaintenance engineer to be concerned with the laborious task ofobtaining and reading documentation.

A software architecture is a description of subsystems, components(subsystems and components are represented by objects of differentgranularity) and the relationships between them. Subsystems andcomponents are typically specified in different views and representfunctional and non-functional properties for a software applicationbased on a software architecture. A software architecture is intended toexhibit software design principles recognized as advantageous (localityprinciple, tight binding, loose coupling, etc.). A software architecturemust take into account different factors that are important to asoftware system or a software architecture: structure, function, data,behavior, dynamics, non-functional properties, etc. These factors can bemodeled by means of sometimes different description means or forms ofrepresentation. Suitable description means include, for example, UML(Unified Modeling Language), comprising a set of different diagram typesand description techniques. The components which can be used in asoftware architecture can be differentiated, for example, into: dataelements (which contain the information), processing elements (whichprocess and/or transform the data elements) and connecting elements(which connect the two other component types to each other or amongthemselves).

All the description means and forms of representation constitute metainformation which according to the depicted invention is present in theobjects of the runtime system at runtime, and can be used on anobject-local basis at runtime.

As a result of the explicit and targeted use of meta information in thesoftware architecture on which a software application is based, thepresent invention has a positive effect in particular on thenon-functional properties of the software application, such asmodifiability, efficiency, reliability, testability, reusability,maintainability, reconfigurabilty, and self-reorganization e.g. in theevent of an error.

The meta information assigned to an object describes, for example, whichdata and functions an object contains, but meta information can alsoinclude implementation and control information or comprise userdocumentation. In markup languages such as HTML or XML, meta informationcan be described by means of what are termed tags or by way ofattributes and assigned to the objects. Meta information can also beprovided with a hierarchical structure. An advantage of the invention isthat no explicit code generation is necessary in order to allow asoftware application to execute.

The objects are black boxes with appropriate access mechanisms forreading the meta data. The runtime logic and the runtime sequence of thesoftware application represented by the tree are specified from thestructure of the tree and from the way it is networked. The structure ofthe tree and the networking of the tree elements determine whichoperands are supplied to functions and whether functions are executedsequentially or in parallel. In industrial installations the structureof the tree and the networking of the tree elements are used todetermine, for example, which input variables are to be supplied toequipment and how the output values generated by the equipment are to befurther processed. Graphical editing of the tree and the networking isperformed by a user in a software development environment. The form ofrepresentation of the trees can vary and can be freely selected by theuser or selected to suit a specific application. The networking orpointer cross-referencing of the tree elements can be achieved by thehierarchical arrangement in the tree. However, networking or pointercross-referencing of the tree elements can also be accomplished by meansof references edited by the user or by lateral networking links toelements of other subtrees. The inputs to create the tree and toestablish networking links can be made using input masks, drag&dropmechanisms or voice input.

The individual objects are assigned their implementation, i.e. theircode and meta information. Because the software application is assembledfrom prefabricated objects at runtime (e.g. automatically on the basisof the meta data relating to the application process), an explicitcompiler phase for generating the code of the software application to beproduced can be dispensed with. Compiler runs can take a very long time.The fact that explicit compiler runs are not required means that thetime taken to produce, test and commission the software application isreduced to a minimum.

A further significant advantage is that programs and data are handled ina uniform manner. Data are object trees without functions, programs areobject trees with functions. All the mechanisms present in a runtimesystem for assembling, networking, versioning, storing, transportingetc. data and programs only need to be implemented once and not once ineach case for data and for programs. This also facilitates theirhandling for software developers, commissioning engineers andadministrators, since they only have to familiarize themselves once withthese mechanisms.

A further advantage is that changes can be implemented very easily.Subtrees can be added, modified or removed at any time without theentire tree structure needing to be changed. This increases the agilityof an enterprise, since the enterprise can react more quickly to changedmarket requirements. This is important most especially when the softwareapplications are used for controlling automation systems, productionequipment or MES systems. The software applications according to theinvention can also be advantageously deployed in the office environment,however.

The networking, pointer cross-referencing or referencing between theobjects can take place using different degrees of granularity. Thus,networking can be achieved e.g. by reference to physical addresses(using pointers), thereby achieving a high level of efficiency (e.g.within the execution of a process). Other networking mechanisms includefor example electronic messages (e.g. e-mail), telephone or fax. Theuser can choose a suitable networking mechanism according to therequirements of the underlying application.

Objects, in the context of the present invention, are those objects thatare used during the development of the software application, but alsoruntime objects. Runtime objects are objects which execute the logic ofthe system at the run time of a system (e.g. an application).

The architecture according to the invention is also suitable for processcontrol systems and production automation systems.

A first advantageous embodiment of the present invention for a softwarearchitecture derives from the fact that at runtime the objects and/orreferencing mechanisms and/or networking mechanisms and/orimplementations of the objects and/or communication mechanisms areinterchangeable. As a result of the fact that objects can be replaced atruntime by other objects, e.g. by objects with extended functionality orthe implementations of objects (e.g. the new implementations have beendebugged or deliver better performance) or referencing and networkingmechanisms, the turnaround time in the event of changes is substantiallyreduced. This increases flexibility for the user and the operator of asystem and the agility of an enterprise. No ordinary compiler is usedfor the analysis of the meta data, but rather a so-called incrementalcompiler or an interpreter which is active on a local object basis onlyat the time of replacement. Code is generated, if necessaryincrementally, for the newly deployed object and the incrementalcompiler or interpreter inserts the newly deployed object (or, as thecase may be, the referencing mechanism and/or networking mechanismand/or a new implementation of objects) into the tree again at runtime,without the need to take into account other (unaffected) parts of thetree.

A further advantageous embodiment of the present invention for asoftware architecture derives from the fact that services can be addedto the objects at runtime. The services use the local object meta datain order to make (MES or control) infrastructure functions genericallyavailable. Services of this kind can include, for example,serialization, replication, encryption or access control. In this waythe objects can be equipped with what is called “Quality of Services”. Auser of an object can rely on the execution of these services andabstract from their implementation.

A further advantageous embodiment of the present invention for asoftware architecture derives from the fact that implementations of thereferencing mechanisms or the networking mechanisms or the communicationmechanisms or the services can be used for data and for programs. Thismeans that the mechanisms and the services do not have to be implementedseparately for data and for programs every time. Furthermore, metainformation can be added to all objects (regardless of whether they aredata objects or program objects) in the same way and the metainformation can be accessed in the same way for all objects.

A further advantageous embodiment of the present invention for asoftware architecture derives from the fact that the objects arenetworked statically and/or dynamically. Networking links (or, as thecase may be, pointer cross-references or references) can be implementedstatically in a manual building of the tree, but can also be generatedautomatically on the basis of current information or meta information(e.g. as necessary). This increases the flexibility for a user.Networking links can be set up using different mechanisms andimplementations: e.g. pointers to objects, e-mail to objects ornetworking via OPC protocols (OPC stands for OLE for Process Control).OPC protocols are frequently used in the industrial environment inparticular. Further techniques or implementations which can be used fornetworking or for linking are, for example, MSMQ (Microsoft MessageQueue), HTTP (Hypertext Transfer Protocol) or SOAP (Simple ObjectTransfer Protocol).

A further advantageous embodiment of the present invention for asoftware architecture derives from the fact that the objects physicallycontain the meta information. This supports the principle of localityduring the development of the software application, i.e. all information(including the meta information) which is important for an object isalso physically present in the object. Access to this information issimplified as a result. Because the objects physically contain the metainformation, an object can also be used on its own for the organization,reorganization or reconfiguration of the software application, as afunction of which meta information (type and scope) is present in theobject. This is of advantage in particular for mobile objects, e.g. forsoftware agents which move from computer to computer on the Internet (orother networked systems such as, for example, an intranet) in order, forexample, to collect information on an installation, in each case on alocal computer basis, in a highly efficient manner e.g. for amaintenance system.

A further advantageous embodiment of the present invention for asoftware architecture derives from the fact that the meta informationcontains static and/or dynamic object models. Object models of this kindinclude, for example, classes and their relationships, state/eventmodels, activity models, deployment models or domain models (e.g. MESprocess model in specific branches of industry such as, for example,automobile manufacture, fertilizer production). This is of advantage inparticular for generic software development or for software generators.

A further advantageous embodiment of the present invention for asoftware architecture derives from the fact that the meta informationdescribes an application or a business process. If the meta informationcontains not only information about the object itself, but alsoinformation about the entire software application, about the deploymentenvironment or about the business process (or business logic) to beimplemented, then the configuration of the software application issimplified as a result, up to a point where a configuration can beperformed automatically. Reconfigurations (e.g. following system crashesor failure of parts of the system) can also be performed automaticallywithout human intervention. This increases the agility of an enterpriseand the availability of the production system.

A further advantageous embodiment of the present invention for asoftware architecture derives from the fact that each individual objectcontains the entire meta information relating to the application or thebusiness process. This means that in a software application or in asoftware system the entire description of the application or also of abusiness process (or, as the case may be, business logic) is containedin each individual object (e.g. in the very smallest tag, in eachvariable or in each operator, i.e. also in the very fine granularobjects). As a result of this information each individual object can beused for a reorganization, but also a self-organization of theapplication, the system or the business process. This is veryadvantageous, for example, in the case of system errors when large partsof the system fail. The system can regenerate itself completely from thesmallest part that is still operational. A maintenance engineertherefore does not need to be concerned with the laborious task ofreturning the system to service.

A further advantageous embodiment of the present invention for asoftware architecture derives from the fact that the trees can berepresented in different views on a display device. The trees can berepresented differently, for example using a static Explorer-likenotation or in the form of workflow or flow diagrams (flowcharts,activity diagrams) or, for example, in the form of block diagrams (e.g.circuit diagrams) or layout plans (e.g. physical equipment layout,material flow plans). This greatly increases the flexibility for a user,for he can choose a notation or visualization appropriate to his levelof knowledge in order to inspect the meta information present in theruntime system. It is also possible to switch between the differentforms of representation.

A further advantageous embodiment of the present invention for asoftware architecture derives from the fact that if an error occurs thesoftware application which is based on the software architecturereconfigures itself. If, in a software application or in a softwaresystem, the entire description of the application or also of a businessprocess is contained in each individual object (e.g. in the verysmallest tag, in each variable or in each operator, i.e. also in thevery fine granular objects), this information can be used for anautomatic reorganization, i.e. a self-healing of the application, thesystem or the business process. User interventions are no longerrequired and downtimes are minimized. There is therefore no need for amaintenance engineer to be concerned with the laborious task ofreturning the system to service.

The meta information assigned to an object describes, for example, whichdata and functions an object contains, but meta information can alsoinclude descriptions relating to implementation and control or compriseuser documentation. In markup languages such as HTML or XML, metainformation can be described by means of what are termed tags or by wayof attributes and assigned to the objects. Meta information can also beprovided with a hierarchical structure. An advantage of the invention isthat no explicit code generation is necessary in order to allow asoftware application to execute. The objects are black boxes withappropriate access mechanisms for reading the meta data. The runtimelogic and the runtime execution sequence of the software applicationrepresented by the tree are specified from the structure of the tree andfrom the way it is networked. The tree's structure, which can bemodified manually or automatically at runtime, and the networking of thetree elements determine which operands are supplied to functions andwhether functions are executed sequentially or in parallel. Inindustrial installations the structure of the tree and the networking ofthe tree elements are used to determine, for example, which inputvariables are to be supplied to equipment and how the output valuesgenerated by the equipment are to be further processed. Graphicalediting of the tree and the networking arrangement is performed by auser in a software development environment. The form of representationof the trees can vary and can be freely selected by the user or selectedto suit a specific application. The networking or pointercross-referencing of the tree elements can be achieved by thehierarchical arrangement in the tree. However, networking or pointercross-referencing of the tree elements can also be accomplished by meansof references edited by the user or by lateral networking links toelements of other subtrees. The inputs to create the tree and toestablish networking links can be made using input masks, drag&dropmechanisms or voice input.

The individual objects are assigned their implementation, i.e. theircode and meta information. Because the software application is assembledfrom prefabricated objects at runtime (e.g. automatically on the basisof the meta data relating to the application process), an explicitcompiler phase for generating the code of the software application to beproduced can be dispensed with. Compiler runs can take a very long time.The fact that explicit compiler runs are not required means that thetime taken to produce, test and commission the software application isreduced to a minimum.

A further advantage is that changes can be implemented very easily.Subtrees can be added, modified or removed at any time without theentire tree structure needing to be changed. This increases the agilityof an enterprise, since the enterprise can react more quickly to changedmarket requirements. This is important most especially when the softwareapplications are used for controlling automation systems, productionequipment or MES systems. The software applications according to theinvention can also be advantageously deployed in the office environment,however.

The networking, pointer cross-referencing or referencing between theobjects can take place using different degrees of granularity. Thus,objects can be networked for example by reference to physical addresses(using pointers), thereby achieving a high level of efficiency (e.g.within the execution of a process). Other networking mechanisms include,for example, electronic messages (e.g. e-mail), telephone or fax. Theuser can choose a suitable networking mechanism according to therequirements of the underlying application.

The method is supported by suitable software development environments.Thus, for example, ready-made objects may be present in a repository andthese can be inserted into the tree using drag&drop or other input aids(e.g. keyboard, light pen). Furthermore it is of advantage if thedisplay device that is used for representing and for building the treescan be split into different screen areas (windowing technique).

Objects, in the context of the present invention, are those objects thatare used during the development of the software application, but alsoruntime objects. Runtime objects are objects which execute the logic ofthe system at the run time of a system (e.g. an application).

The method according to the invention is also suitable for thedevelopment of software applications for process control systems andproduction automation systems.

A first advantageous embodiment of the present invention for a methodderives from the fact that at runtime the objects and/or referencingmechanisms and/or networking mechanisms and/or implementations of theobjects are interchangeable. As a result of the fact that objects can bereplaced at runtime by other objects, e.g. by objects with extendedfunctionality or the implementations of objects (e.g. the newimplementations have been debugged or deliver better performance) orreferencing and networking mechanisms, the turnaround time in the eventof changes is substantially reduced. This increases flexibility for theuser and the operator of a system and the agility of an enterprise. Noordinary compiler is used for the analysis of the meta data, but rathera so-called incremental compiler or an interpreter which is active on alocal object basis only at the time of replacement. Code is generated,if necessary incrementally, for the newly deployed object and theincremental compiler or interpreter inserts the newly deployed object(or, as the case may be, the referencing mechanism and/or networkingmechanism and/or a new implementation of objects) into the tree again atruntime, without the need to take into account other (unaffected) partsof the tree.

A further advantageous embodiment of the present invention for a methodderives from the fact that services can be added to the objects atruntime. The services use the local object meta data in order to make(MES or control) infrastructure functions generically available.Services of this kind can include, for example, serialization,replication, encryption or access control. In this way the objects canbe equipped with what is called “Quality of Services”. A user of anobject can rely on the execution of these services and abstract fromtheir implementation.

A further advantageous embodiment of the present invention for a methodderives from the fact that implementations of the referencing mechanismsor the networking mechanisms or the services can be used for data andfor programs. This means that the mechanisms and the services do nothave to be implemented separately for data and for programs every time.Furthermore, meta information can be added to all objects (regardless ofwhether they are data objects or program objects) in the same way andthe meta information can be accessed in the same way for all objects.

A further advantageous embodiment of the present invention for a methodderives from the fact that the objects are networked statically and/ordynamically. Networking links (or, as the case may be, pointercross-references or references) can be implemented statically in amanual building of the tree, but can also be generated automatically onthe basis of current information or meta information (e.g. asnecessary). This increases the flexibility for a user. Networking linkscan be set up using different mechanisms and implementations: e.g.pointers to objects, e-mail to objects or networking via OPC protocols(OPC stands for OLE for Process Control). OPC protocols are frequentlyused in the industrial environment in particular. Further techniques orimplementations which can be used for networking or for linking are, forexample, MSMQ (Microsoft Message Queue), HTTP (Hypertext TransferProtocol) or SOAP (Simple Object Transfer Protocol).

A further advantageous embodiment of the present invention for a methodderives from the fact that the objects physically contain the metainformation. This supports the principle of locality during thedevelopment of the software application, i.e. all information (includingthe meta information) which is important for an object is alsophysically present in the object. Access to this information issimplified as a result. Because the objects physically include the metainformation, an object can also be used on its own for the organization,reorganization or reconfiguration of the software application, as afunction of which meta information (type and scope) is present in theobject. This is of advantage in particular for mobile objects, e.g. forsoftware agents which move from computer to computer on the Internet (orother networked systems such as, for example, an intranet) in order, forexample, to collect information on an installation, in each case on alocal computer basis, in a highly efficient manner e.g. for amaintenance system.

A further advantageous embodiment of the present invention for a methodderives from the fact that the meta information contains static and/ordynamic object models. Object models of this kind include, for example,classes and their relationships, state/event models, activity models,deployment models or domain models (e.g. MES process model in specificbranches of industry such as, for example, automobile manufacture,fertilizer production). This is of advantage in particular for genericsoftware development or for software generators.

A further advantageous embodiment of the present invention for a methodderives from the fact that the meta information describes an applicationor a business process. If the meta information contains not onlyinformation about the object itself, but also information about theentire software application, about the deployment environment or aboutthe business process (or business logic) to be implemented, then theconfiguration of the software application is simplified as a result, upto a point where a configuration can be performed automatically.Reconfigurations (e.g. following system crashes or failure of parts ofthe system) can also be performed automatically without humanintervention. This increases the agility of an enterprise.

A further advantageous embodiment of the present invention for a methodderives from the fact that each individual object contains the entiremeta information relating to the application or the business process.This means that in a software application or in a software system theentire description of the application or also of a business process iscontained in each individual object (e.g. in the very smallest tag, ineach variable or in each operator, i.e. also in the very fine granularobjects). As a result of this information each individual object can beused for a reorganization, but also a self-organization of theapplication, the system or the business process. This is veryadvantageous, for example, in the case of system errors when large partsof the system fail. The system can regenerate itself completely from thesmallest part that is still operational. A maintenance engineertherefore does not need to be concerned with the laborious task ofreturning the system to service.

A further advantageous embodiment of the present invention for a methodderives from the fact that the trees can be represented in differentviews on a display device. The trees can be represented differently,e.g. using a static Explorer-like notation or in the form of workflow orflow diagrams (flowcharts, activity diagrams) or, for example, in theform of block diagrams (e.g. circuit diagrams) or layout plans (e.g.physical equipment layout, material flow plans). This greatly increasesthe flexibility for a user, for he can choose a notation orvisualization appropriate to his level of knowledge in order to inspectthe meta information present in the runtime system. It is also possibleto switch between the different forms of representation.

A further advantageous embodiment of the present invention for a methodderives from the fact that if an error occurs the software applicationreconfigures itself. If, in a software application or in a softwaresystem, the entire description of the application or also of a businessprocess is contained in each individual object (e.g. in the verysmallest tag, in each variable or in each operator, i.e. also in thevery fine granular objects), this information can be used for anautomatic reorganization, i.e. a self-healing of the application, thesystem or the business process. User interventions are no longerrequired and downtimes are minimized. There is therefore no need for amaintenance engineer to be concerned with the laborious task ofobtaining and reading documentation.

A further advantageous embodiment of the present invention consists in asoftware development environment which is integrated into the runtimesystem, with selectable functionalities being accessed via views. Thetraditional software development environment is thus reduced torepresentations and editors by means of which the runtime system can beobserved and modified directly. Advantages of this constructionprinciple or of this architecture include system and data consistency,as well as easier modifiability of the runtime system. Thus, the views,which are implemented for example by means of editors, can be used toaccess application functions of the runtime system (operator view) orelse to implement changes or expansions (engineering or maintenanceview).

A further advantageous embodiment of the present invention is that theinventive software application or the inventive method and the softwaredevelopment environment are implemented by means of a computer program.This means that any modifications or adaptations can be easily carriedout.

further advantageous embodiment of the present invention is that thecomputer program for the inventive method and/or for the softwaredevelopment environment is stored on a data medium. This makes themethod easy to handle with regard to logistics and distribution. Datamedia are, for example, familiar computer program products such as, forexample, floppy disks or CDs.

A further advantageous embodiment of the present invention is that thecomputer program for the inventive method and/or for the softwaredevelopment environment is installed on a data processing device.Performance is increased as a result.

Further advantages and details of the invention will emerge withreference to the following description of advantageous exemplaryembodiments and in connection with the figures. Insofar as elementshaving identical functionalities are described in different figures,said elements are designated by means of the same reference symbols.

BRIEF DESCRIPTION OF THE DRAWINGS

FIG. 1 shows in a schematic overview representation the “enterprisepyramid” with three control levels,

FIG. 2 shows a schematic representation with a traditional softwaredevelopment environment, a runtime system and a technical process thatis to be controlled,

FIG. 3 shows the schematic representation of an object,

FIG. 4 shows the tree structure of a software application,

FIG. 5 shows a form of representation of a tree,

FIG. 6 shows a further form of representation of a tree,

FIG. 7 shows a schematic representation comprising a runtime system anda technical process that is to be controlled, with functions of thesoftware development environment being integrated into the runtimesystem, and

FIG. 8 shows in a graphic representation aspects which determine asoftware architecture.

DETAILED DESCRIPTION OF INVENTION

The diagram according to FIG. 1 shows in a schematic overviewrepresentation the three control levels such as they are typically to befound in a producing or manufacturing enterprise. The pyramid shape ofthe diagram is intended to convey that a compression of the informationtakes place from the bottom up. The topmost level is the ERP (EnterpriseResource Planning) level. It is at this executive management level of anenterprise that the business administration and sales functions in theenterprise are usually performed (e.g. finance, sales and marketing,human resources, reporting). However, logistical tasks extending acrossdifferent production systems are also performed at this level (e.g. jobscheduling and materials management). The SAP R/3 system is an ERPsystem which is very frequently used at the enterprise resource planninglevel.

The lowest level of the pyramid is the automation level (Controls). Atthis level stored program controllers (SPS) are usually used inconjunction with visualization and process control systems (PLS). Thedrives, actuators and sensors of the production and/or manufacturingequipment are directly connected to the systems of this level.

The connecting element between the ERP level and the automation level isformed by the MES level. The applications of the MES level thus providea means of vertical integration between the ERP level and the automationlevel. On the one hand the MES applications must supplement the generalplanning data of the ERP systems with production system-specificdetailed planning data and forward this information to the systems ofthe automation level, while on the other hand it is the task of the MESapplications to accept, edit and then forward production-related datafrom the automation level to the ERP level (executive management levelof the enterprise).

Typical MES applications include quality management (QM), maintenancemanagement (MM), performance analysis (PA), process management, labormanagement, and asset management. The three dots shown at each level inFIG. 1 are intended to convey that there may be further elements(applications, systems, etc.) at a particular level.

MES systems or ERP systems as a rule contain what is known as a runtimesystem for scheduling the execution times of the components involved(subcomponents, modules, tasks, operating system processes, etc.), aswell as what is known as an engineering system for creating and editingprograms which are provided for execution in the runtime system.

The diagram according to FIG. 2 shows a schematic representationcomprising a traditional software development environment SU, a runtimesystem RTS and a technical process TP1 that is to be controlled. Thesedays, software applications are developed methodically and according tobest-practice engineering principles. Tools (called CASE tools, whereCASE stands for Computer Aided software Engineering) are typically usedfor this purpose. These CASE tools support compliance with methods andstandards in order to increase the productivity of the softwaredevelopers, but also to improve the quality of the software produced.The CASE tools are made available to the software developers via asoftware development environment SU. This software developmentenvironment SU is part of the workstation for a software producer. Asoftware development environment SU supports a software producer in allphases of software development, i.e. from the early analysis phasesthrough to the late testing phases. Suitable utility routines, such ase.g. editor, compiler, and debugger, but also analytical and designtools, are available to a developer for all the phases of softwaredevelopment.

The workstation of a software developer typically consists of acomputing unit with processor and memory, together with output unitssuch as screen, display and input aids such as keyboard and mouse aswell as the utility routines that are required for software development(editor, compiler, etc.). These utility routines can be very easilyinvoked and used by a software developer via a suitable softwaredevelopment environment SU. Modern software development environments SUalso enable access to configuration management tools and to changemanagement tools.

Today's advanced software development environments SU support inparticular the paradigms of object orientation such as the creation ofobjects, the creation of classes, the creation of superclasses, as wellas the representation of inheritance relationships. Suitable editors,mask input or drag&drop mechanisms are used to link the objects withmeta information, structure the objects as hierarchical trees and alsonetwork them with one another. The software applications produced withthe aid of the software development environment SU must finally beexecuted on a target system or on a target computer in order, forexample, to control a technical process TP1. The target system typicallyconsists of one computing unit to a plurality of computing units withprocessors and storage devices as well as a runtime system RTS. Theprograms developed with the aid of the software development environmentSU are loaded onto the runtime system RTS via the information path I.The underlying technical process, e.g. for an automation solution or anMES solution, is controlled via the input/output connection EA1.Actuators, for example, are influenced from the runtime system RTS tothe technical process TP1 via the I/O connection EA1, while sensor data,for example, is supplied from the technical process TP1 back to theruntime system RTS via the I/O connection EA1, which sensor data is thenprocessed further in the software application. A runtime system RTS canalso be distributed across a plurality of computer units.

The diagram according to FIG. 3 shows the schematic representation of anobject with an object interface OI. An object is generally an object oran element of a domain or a discourse world. In object-oriented softwaredevelopment, an object is an individual exemplar of things or entities(e.g. robot, car, machine), persons (e.g. customer, employee, patentattorney) or concepts from the real world (e.g. order) or the conceptualworld (e.g. juristic and natural persons or organizations). An objectpossesses a certain defined state and reacts with a defined behavior toits environment. Each object also possesses an object identity whichdistinguishes it from all other objects and which permits it to access aspecific object. An object can know one or more other objects.Connections or pointer cross-references or networking links existbetween objects that know each other. The state of an object isdetermined by its data or attribute values and the particularconnections to other objects. The behavior of an object is defined byits set of methods or operations. In object-oriented programming, thetype of an object is described by a class. Real incarnations orinstances, which then correspond to an actual programming languageobject, can be generated from this type description. Objects and theirconnections can be represented graphically with the aid of objectdiagrams. The editors used for object diagrams are part of the softwaredevelopment environment (SU; FIG. 2). UML (Unified Modeling Language)provides a number of notations for the graphical representation ofobject-oriented concepts (business process diagram, state diagram,activity diagram, collaboration diagram, sequence diagram, classdiagrams, etc.). These diagrams can be edited and processed by a userwith the software development environment (SU; FIG. 2).

The left-hand part of FIG. 3 shows the information or elements which anobject usually contains. Data includes such simple things as a numericvalue but also complex structures such as recipes, orders or archives.Methods (often also referred to as operations) represent executableactivities in relation to an algorithm. The set of methods determinesthe behavior of an object instantiated by this class. The methods of anobject can be used or invoked by other objects in a comparable way to aclient-server architecture. Moreover, objects can contain so-calledsubobjects, which they require in order to implement their methods. Astructural organization of an object is determined by the subobjects.

On the right-hand side of the diagram shown in FIG. 3, an element knownas a container is depicted by hatching. The inventive mechanisms forholding the meta information and the mechanisms for accessing this metainformation are implemented by means of this container. The containersrepresent an encapsulating layer around the object, and all accesses toan object can only be effected via the interface OI. The methods anddata and also the meta information of the object are accessed via theinterface OI. In an access to the data, the methods or the metainformation a user can therefore abstract from the implementation ofdata methods and meta information. All accesses to an object areeffected via the interface OI. This can very greatly facilitate thereusability and interchangeability of objects. Thus, even in a complexsystem, for example a software system, objects can always be accessed inthe same way. In particular, the containers make infrastructurefunctions such as data networking, data storage and data visualizationavailable in a uniform way for all types of objects (for examplebusiness objects). A double helix comparable to a DNA structure of ahuman cell is depicted schematically in the container. This is intendedto illustrate that an object contains parts or all of the metainformation, that is to say also the structural information and thelogic that is inherent in, for example, a business process. This enablesthe entire system or the entire application to be organized orreorganized from a single object. As a result, downtimes of a system canbe minimized and maintenance work completed very efficiently.

The infrastructure functions that a container provides also include, forexample, trace functions, in other words, who has used an object, andfor how long. As mentioned already, the container contains metainformation, self-description information for the object. This enablesmeasurements, but also security mechanisms, to be inserted as well.

The diagram according to FIG. 4 shows the tree structure of a softwareapplication. In this case the objects are represented as double circles.The inner circle schematically represents the structure of an object, asknown from FIG. 3. Here, the left half of an object again represents thedata methods and subobjects, while the right hatched half represents thecontainer which contains the meta information and provides theinfrastructure information for an object. The container represents anencapsulating layer for the object. The object can only be accessed viathe object interface OI which is provided by the container.Infrastructure functions include, for example, data networking, datastorage and data visualization. The container makes these functionsavailable in a uniform way for all other objects.

The outer circles around the objects signify that the objects areultimately embedded in the infrastructure of a system. One aspect of theinfrastructure is the networking. Networking or cross-referencing bypointer can be implemented in a very fine granular way, e.g. via storagepointers. However, it can also be effected via the Internet, via e-mailor via telephone connections.

In the diagram according to FIG. 4, the connecting lines drawn in boldbetween the objects indicate that these objects are interconnectedlaterally. In the industrial environment, a lateral connection of thiskind can be, for example, a connection via OPC (OLE for ProcessControl). Such a connection or, as the case may be, an infrastructureservice can also be implemented via message queue mechanisms. Access toinfrastructure services or functionalities is provided via the containerand is the same for all the objects in a tree, regardless of whether theobject is a B&B (operator control and monitoring) device or a storedprogram controller (SPS). For this reason it is also very easy to modifythe implementation of an infrastructure service, since the specificationremains unchanged. The outer circle of an object therefore represents acollection of infrastructure services or infrastructure functions whichcan be used via a container. Once implemented, an infrastructure servicecan be used by all objects in the same way.

The diagram according to FIG. 4 shows a software application in whichthe objects are structured in the form of a hierarchical tree. Thesystem to be implemented or the software application contains a B&Bdevice with a database DB, with the B&B device being supplied by astored program controller (SPS). The SPS accesses actuators and sensorsvia input/output functions. The results of the operator control andmonitoring (B&B) device are processed further by an object “Execution”.The algorithm for this further processing in the object “Execution” isrepresented by the subtree hanging under the object “Execution”. In thiscase a value X1 is processed by means of a function F, where thefunction F is assigned the value X2 as input value. Following theexecution of this Execution component, further post-processingoperations are performed, represented by the objects “Postprocessing 1”and “Postprocessing 2”. The operations performed here can be, forexample, compression or display functions. FIG. 4 illustrates that theresults of the post-processing by “Postprocessing 1” undergo a furtherprocessing step by the object “Further Processing”. A software system orsoftware application described in this way can of course be combinedwith further software applications described in this way and form partof a higher-order world, depicted here in FIG. 4 by the object “World”.

In addition to the hierarchical structuring, as given by the structureof the tree, the objects can also be networked, reflected orcross-referenced laterally and/or horizontally with one another by meansof pointers. This is indicated in FIG. 4 by the bold lines. Pointercross-references of this kind can be modeled via input masks or alsoestablished using drag&drop mechanisms.

The function that is implemented by a software system or by a softwareapplication results from the structure, the hierarchy and the networkingof the tree objects. The tree elements, in other words the objects, areprocessed and executed as a function of a traversing algorithm that isto be provided as a basis. The execution of a software application iscomparable with the mode of operation of the human nervous system, wherethe individual neurons are interconnected via dendrites and synapses andexchange their activities among one another, with a stimulus triggeringa chain of impulses through the body and a chain of impulses of thiskind is executed according to how the neurons are networked. In thesystem or software application or even software architecture accordingto the invention, a chain of events is also triggered by the structureand the networking of the objects which are comparable with the neuronsin the human body, as by a stimulus as shown in FIG. 4, e.g. when asensor forwards an event to an SPS and this event is registered via theB&B device and then an execution is started which in turn triggers“Postprocessing 1” and “Postprocessing 2” to perform a furtherprocessing operation, whereby after the further processing“Postprocessing 1” initiates another further processing operation.Software applications produced in this way have very advantageousproperties. Thus, for example, the objects that are required for anapplication are not combined until runtime, as a result of which suchapplications exhibit very high levels of modifiability and flexibility.If changes are to be made, an object does not have to be compiled first.An object which is newly introduced into the system and replaces anotherone can be very easily integrated if it has the same interface and thesame specification as the object to be replaced and only differs in itsimplementation, for example by delivering better performance.

The diagram according to FIG. 5 shows a form of representation for atree. FIG. 5 depicts a display device AZ1 having the two screen areasBB1 and BB2. A display device AZ1 can be, for example, a monitor or adisplay. The display device AZ1 is typically an element of a softwaredevelopment environment (SU; FIG. 2). Display devices and input aidssuch as, for example, keyboard or mouse are used to generate objects onthe screen, structure them hierarchically in the form of a tree and linkthem to one another by means of networking or pointers, but also toprovide them with meta information or other information. It isconceivable that a display device AZ1 contains further screen areas forthe representation of trees, but also to implement inputs (e.g. menubars). A software application is assembled at runtime from the objectsof a tree. The structure is important for the processing of the objects,but so also is the networking of the objects. If a user (for example asystems integrator or maintenance engineer) wants to introduce changes,then he requires a representation of the tree that satisfies hiscorresponding requirements and needs. In the diagram as depicted in thescreen area BB1 on the left-hand side of FIG. 5, a tree OB1 is shownwith the tree elements K1, K2, K3, K4, and what's more it is shown in anExplorer-like notation. The representation of a tree as shown in thescreen area BB2 corresponds to a notation as used, for example, forcircuit diagrams. The elements K1′ and K2′ shown in the screen area BB2are represented as a tree structure via input (x1, x2) and outputvariables (r1, r2) which are interconnected by lines in each case. Arepresentation in this form of circuit diagrams is of interest inparticular to electricians, for electricians think in terms of circuitdiagrams. It is possible to modify the representation of a tree by wayof input aids and to choose the most practical form of representationfor the particular user group in each case. User groups are, forexample, maintenance engineers, systems integrators and developers, butalso marketing and sales people.

The diagram according to FIG. 6 shows a further possible way in which atree can be represented on a display device AZ2. The left-hand sectionof FIG. 6 shows a screen area BB1′ with an object tree OB2 in anExplorer-like structure. The right-hand part of FIG. 6 shows a screenarea BB2′ in which a tree is represented using a notation which is veryadvantageous, in particular for the representation of businessprocesses. People in the accounting department or in the management ofthe enterprise think in terms of such business process workflows(business processes). The degree of user friendliness and also ofefficiency when trees are created or when trees are modified is greatlyincreased by the possibility of switching between different forms ofrepresentation. It means that a user can abstract from the internalrepresentation or implementation of a tree. When creating a tree ormodifying a tree, there is nothing to be programmed from scratch, butinstead everything can be configured for the specific project. This isadvantageous for efficiency in the production of software applications,but also for the creation of software architectures.

The diagram according to FIG. 7 shows a schematic representation with anextended runtime system RTS/SU and a technical process TP2 that is to becontrolled, with functions of the software development environment beingintegrated in the extended runtime system RTS/SU. The functions requiredin a particular case are accessed by what are known as views. FIG. 7shows views for development (SU View), for operator control (OperatorView) and for maintenance (Maintenance View). The ellipsis serves toindicate that further views may be present. The extended runtime systemRTS/SU contains the infrastructure for the development and modificationof the runtime system. The connection to the technical process TP2 to becontrolled is established via input/output connections EA2.

It is a significant effect of the invention that large parts of thefunctionality of a traditional software development environment (SU;FIG. 2) are covered by the runtime system RTS/SU. Meta data is to agreat extent data which is generated in any case in the course ofdevelopment. Thus, runtime system and software development environmentcan, as it were, merge with each other and no longer have to be embodiedas separate components. A system which is modifiable contains manyaspects at runtime which today are only present in developmentenvironments (modeling, versioning, compilation, etc). The traditionalsoftware development environment is reduced to representations andeditors by means of which the runtime system can be observed andmodified directly.

Advantages of the design principle or of this architecture include notonly the easier modifiability of the runtime system, but also systemconsistency. All components which contain or reference the meta data areself-descriptive. The composition of the components produces an entiresystem description. In other words, however the system is modified (e.g.inserting or removing modules), the views (engineering views) are alwaysable to show the currently existing system. UML diagrams, businessprocess diagrams, circuit diagrams, layout plans, etc. are always at thelatest status.

The diagram according to FIG. 8 shows the aspects which determine asoftware architecture SA. The creation of software architectures SAcalls for abstract and conceptual thought processes. The architectureproposed according to the invention ensures that no structural hiatusoccurs between the analysis phase and the design phase. In an analysisphase, the objects required for a software architecture are identified,linked with meta information and structured as hierarchical trees. Theobjects can also be laterally and/or horizontally networked with oneanother and are able to communicate with one another or with theenvironment via communication mechanisms. The function of a softwareapplication that is based on a software architecture is determined bythe arrangement of the objects relative to one another. At runtime theobjects are then assembled into a software application, whereby thesoftware application inherently contains principles which arepredetermined by the software architecture. This ensures that no designbreak occurs.

A software architecture must take account of different factors, aspectsor views. This includes the function which is ultimately to be achievedby a software application which is based on the architecture. Thefunctionality resides typically and in particular in the methods andoperations of the objects. The behavior and the dynamics are determinedin particular by the interaction of the objects and by the interactionof the operations present in the objects. The data aspect is usuallydetermined via the attributes. The attributes also determine the statesof an object, with the states also being determined by the respectiveconnections to other objects. The structural aspect includes thehierarchical structure of a tree with its objects with regard to a“consists of” relation. In a software architecture, however, thestructural aspect is also introduced by the “is a” relation. Thecommunication aspect is very important within a software architecture,for the communication mechanisms used ensure that the objects that areused for an application can exchange data with one another, i.e. cancommunicate, at all. Communication mechanisms include, for example, MQ(Message Queues), what are known as middleware platforms, such as COM,DCOM or CORBA, or also layers that sit on top of them, such as the OPC(OLE for Process Control) protocol. The choice of communicationmechanisms has a quite decisive influence on a software architecture.Synchronization mechanisms and the capability to execute in parallel arealso influenced by them.

For current software architectures and for software applications thatare based on them, the aspect of non-functional properties is becomingincreasingly important. Non-functional properties include, for example,modifiability, efficiency, reliability, testability or reusability. Thetargeted and explicit use of meta information in a software architectureenormously advances the realization of non-functional properties. Owingto the fact that the individual objects contain meta information notonly about themselves, but also about the applications in which they areused or in the business processes in which they are used,self-organizations of a software application can be performed veryeasily, i.e. an automatic recovery can take place without a humanoperator having to intervene. The said aspects which are important for asoftware architecture are typically modeled and edited by a user bymeans of CASE (Computer-Aided Software Engineering) tools withappropriate program editors. These CASE tools form part of a softwaredevelopment environment (SU; FIG. 2). Suitable options for thedescription of a software architecture as proposed in the inventioninclude, for example, the diagrams provided by the UML (Unified ModelingLanguage) method.

Meta information can be very elegantly and easily coupled to and/orintroduced into objects and also systems through the use of markuplanguages. XML (Extended Markup Language) in particular offers optionsallowing easy formulation of meta information. Meta information can bestored in XML for example as elements (enclosed by a start tag and anend tag) or as attributes (directly integrated into a start tag).

To sum up, the invention relates to software applications, softwarearchitectures and methods for building software applications, inparticular for MES systems, wherein objects (comprising data,attributes, behaviors, functions) for software applications, inparticular MES applications, are linked with meta information, theobjects are structured as hierarchical trees (with different forms ofrepresentation being selectable) and the objects are linked with oneanother by means of pointers or are networked (laterally and/orhorizontally). At runtime the objects are assembled into softwareapplications, with the overall function of the software applicationsbeing derived from the structure of the hierarchical trees. Softwareapplications or software architectures can be created for MES systems,for automation systems, for industrial controllers (including motioncontrollers) and for office applications (office environment).

The above described software application or software developmentenvironment according to the invention can be implemented as a computerprogram in languages known for this purpose. A computer programimplemented in such a way can be stored and transported in a likewiseknown manner via electronic data paths.

1. A software application, comprising objects having and/or referencingdata and/or attributes and/or behaviors, wherein the objects run and/orare stored on at least one computing unit, wherein a plurality of theobjects each physically comprise meta information about themselves andabout the software application, and the objects are linked with metainformation at runtime, wherein the objects are structured ashierarchical trees at runtime, wherein the objects are networkedlaterally and/or horizontally and/or referenced at runtime, wherein thesoftware application is assembled by linking the objects with metainformation at runtime, the objects being networked laterally orhorizontally, the overall function of the software application beingderived from the structure of the hierarchical trees as well as from thenetworking of the objects in the trees.
 2. The software applicationaccording to claim 1, wherein the objects and/or referencing mechanismsand/or networking mechanisms and/or implementations of the objects areinterchangeable at runtime.
 3. The software application according toclaim 1, wherein services are added to the objects at runtime.
 4. Thesoftware application according to claim 1, wherein implementations ofthe referencing mechanisms or the networking mechanisms or of servicesare used for data and/or for programs.
 5. The software applicationaccording to claim 1, wherein the objects are networked staticallyand/or dynamically.
 6. The software application according to claim 1,wherein the meta information comprises static and/or dynamic objectmodels.
 7. The software application according to claim 1, wherein themeta information describes an application or a business process.
 8. Thesoftware application according to claim 1, wherein each individualobject comprises the entire meta information relating to the applicationor the business process.
 9. The software application according to claim1, wherein the trees are represented different on a display device. 10.The software application according to claim 1, wherein in the event ofan error the software application reconfigures itself.
 11. The softwareapplication according to claim 1, wherein the software application is aMES application.
 12. A software architecture enabling both assembly andexecution of a software application at runtime, the architecturecomprising: objects having and/or referencing data and/or attributesand/or behaviors, wherein the objects run and/or are stored on acomputing unit, wherein the objects are linked with meta information atruntime, wherein the objects are structured as hierarchical trees atruntime, wherein the objects are laterally and/or horizontally networkedat runtime, wherein a plurality of the objects each physically comprisethe meta information, wherein the objects communicate with one anotherand/or with the environment at runtime by a communication mechanism, sothat the software application is assembled at runtime from the linkingof the objects with meta information at runtime, and wherein the overallfunction of the software application which is based on the softwarearchitecture is determined from the metadata and the structure of thehierarchical trees and from the networking of the objects in the trees.13. The software architecture according to claim 12, wherein the objectsand/or referencing mechanisms and/or networking mechanisms and/orimplementations of the objects and/or communication mechanisms areinterchangeable at runtime.
 14. The software architecture according toclaim 12, wherein services are added to the objects at runtime and eachindividual object comprises the entire meta information relating to theapplication or the business process.
 15. The software architectureaccording to claim 12, wherein implementations of the referencingmechanisms or the networking mechanisms or the communication mechanismsor the services are used for data and/or for programs.
 16. The softwarearchitecture according to claim 12, wherein the objects are networkedstatically and/or dynamically.
 17. The software architecture accordingto claim 12, wherein the meta information comprises static and/ordynamic object models.
 18. The software architecture according to claim12, wherein the meta information describes an application or a businessprocess.
 19. The software architecture according to claim 12, wherein anobject comprises the entire meta information relating to an applicationor a business process.
 20. The software architecture according to claim12, wherein the trees are represented in different views on a displaydevice.
 21. The software architecture according to claim 12, wherein inthe event of an error the software application based on the softwarearchitecture reconfigures itself.
 22. The software architectureaccording to claim 12, wherein the software architecture is used for aMES application.
 23. A method for building a software application,comprising: providing a computing unit; providing input aids; providingoutput aids; providing a display device; creating objects whichrepresent units of the software application using the input aids and thedisplay device; assigning meta information to the objects using theinput aids and the display device, wherein a plurality of the objectsphysically comprise the meta information, including meta informationabout themselves and about the software application; structuring theobjects as hierarchical trees using the input aids and the displaydevice; networking the objects at runtime using the input aids and thedisplay device thereby automatically assembling the objects to form thesoftware application at runtime wherein the function of the softwareapplication is automatically derived at runtime from the structure ofthe hierarchical trees, the networking of the objects in the trees, andthe assigned meta information.
 24. The method according to claim 23,wherein the objects and/or referencing mechanisms and/or networkingmechanisms and/or implementations of the objects are interchangeable atruntime.
 25. The method according to claim 23, wherein services areadded to the objects at runtime and each individual object comprises theentire meta information relating to the application or the businessprocess.
 26. The method according to claim 23, wherein implementationsof the referencing mechanisms or of the networking mechanisms or of theservices are used for data and/or for programs.
 27. The method accordingto claim 23, wherein the objects are networked statically and/ordynamically.
 28. The method according to claim 23, wherein the metainformation comprises static and/or dynamic object models.
 29. Themethod according to claim 23, wherein the meta information describes anapplication or a business process.
 30. The method according to claim 23,wherein an object comprises the entire meta information relating to theapplication or a business process.
 31. The method according to claim 23,wherein the trees can be represented in different views on a displaydevice.
 32. The method according to claim 23, wherein in the event of anerror the software application reconfigures itself.
 33. The methodaccording to claim 23, wherein the software application is used for aMES system.
 34. The method according to claim 23, wherein the method isimplemented by a computer program.
 35. The method according to claim 34,wherein the computer program is stored on a data medium.
 36. The methodaccording to claim 34, wherein the computer program is installed on adata processing device.
 37. The method according to claim 23, wherein asoftware development environment is adapted for performing the method.38. The method according to claim 37, wherein the software developmentenvironment is integrated into a runtime system, with selectablefunctionalities being accessed via views.
 39. The method according toclaim 37, wherein the software development environment is implemented bya computer program.